home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / ninjakd2.c < prev    next >
C/C++ Source or Header  |  2000-05-04  |  6KB  |  240 lines
  1. #include "driver.h"
  2. #include "vidhrdw/generic.h"
  3.  
  4. #define COLORTABLE_START(gfxn,color)    Machine->drv->gfxdecodeinfo[gfxn].color_codes_start + \
  5.                     color * Machine->gfx[gfxn]->color_granularity
  6. #define GFX_COLOR_CODES(gfxn)         Machine->gfx[gfxn]->total_colors
  7. #define GFX_ELEM_COLORS(gfxn)         Machine->gfx[gfxn]->color_granularity
  8.  
  9. unsigned char     *ninjakd2_scrolly_ram;
  10. unsigned char     *ninjakd2_scrollx_ram;
  11. unsigned char     *ninjakd2_bgenable_ram;
  12. unsigned char     *ninjakd2_spoverdraw_ram;
  13. unsigned char     *ninjakd2_spriteram;
  14. size_t ninjakd2_spriteram_size;
  15. unsigned char     *ninjakd2_background_videoram;
  16. size_t ninjakd2_backgroundram_size;
  17. unsigned char     *ninjakd2_foreground_videoram;
  18. size_t ninjakd2_foregroundram_size;
  19.  
  20. static struct osd_bitmap *bitmap_bg;
  21. static struct osd_bitmap *bitmap_sp;
  22.  
  23. static unsigned char      *bg_dirtybuffer;
  24. static int          bg_enable = 1;
  25. static int          sp_overdraw = 0;
  26.  
  27. int ninjakd2_vh_start(void)
  28. {
  29.     int i;
  30.  
  31.     if ((bg_dirtybuffer = malloc(1024)) == 0)
  32.     {
  33.         return 1;
  34.     }
  35.     if ((bitmap_bg = osd_new_bitmap (Machine->drv->screen_width*2,Machine->drv->screen_height*2,Machine->scrbitmap->depth)) == 0)
  36.     {
  37.         free (bg_dirtybuffer);
  38.         return 1;
  39.     }
  40.     if ((bitmap_sp = osd_new_bitmap (Machine->drv->screen_width,Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
  41.     {
  42.         free (bg_dirtybuffer);
  43.         free (bitmap_bg);
  44.         return 1;
  45.     }
  46.     memset(bg_dirtybuffer,1,1024);
  47.  
  48.     /* chars, background tiles, sprites */
  49.     memset(palette_used_colors,PALETTE_COLOR_USED,Machine->drv->total_colors * sizeof(unsigned char));
  50.  
  51.     for (i = 0;i < GFX_COLOR_CODES(1);i++)
  52.     {
  53.         palette_used_colors[COLORTABLE_START(1,i)+15] = PALETTE_COLOR_TRANSPARENT;
  54.         palette_used_colors[COLORTABLE_START(2,i)+15] = PALETTE_COLOR_TRANSPARENT;
  55.     }
  56.     return 0;
  57. }
  58.  
  59. void ninjakd2_vh_stop(void)
  60. {
  61.     osd_free_bitmap(bitmap_bg);
  62.     osd_free_bitmap(bitmap_sp);
  63.     free(bg_dirtybuffer);
  64. }
  65.  
  66.  
  67. WRITE_HANDLER( ninjakd2_bgvideoram_w )
  68. {
  69.     if (ninjakd2_background_videoram[offset] != data)
  70.     {
  71.         bg_dirtybuffer[offset >> 1] = 1;
  72.         ninjakd2_background_videoram[offset] = data;
  73.     }
  74. }
  75.  
  76. WRITE_HANDLER( ninjakd2_fgvideoram_w )
  77. {
  78.     if (ninjakd2_foreground_videoram[offset] != data)
  79.         ninjakd2_foreground_videoram[offset] = data;
  80. }
  81.  
  82. WRITE_HANDLER( ninjakd2_background_enable_w )
  83. {
  84.     if (bg_enable!=data)
  85.     {
  86.         ninjakd2_bgenable_ram[offset] = data;
  87.         bg_enable = data;
  88.         if (bg_enable)
  89.          memset(bg_dirtybuffer, 1, ninjakd2_backgroundram_size / 2);
  90.         else
  91.          fillbitmap(bitmap_bg, palette_transparent_pen,0);
  92.     }
  93. }
  94.  
  95. WRITE_HANDLER( ninjakd2_sprite_overdraw_w )
  96. {
  97.     if (sp_overdraw!=data)
  98.     {
  99.         ninjakd2_spoverdraw_ram[offset] = data;
  100.         fillbitmap(bitmap_sp,15,&Machine->drv->visible_area);
  101.         sp_overdraw = data;
  102.     }
  103. }
  104.  
  105. void ninjakd2_draw_foreground(struct osd_bitmap *bitmap)
  106. {
  107.     int offs;
  108.  
  109.     /* Draw the foreground text */
  110.  
  111.     for (offs = 0 ;offs < ninjakd2_foregroundram_size / 2; offs++)
  112.     {
  113.         int sx,sy,tile,palette,flipx,flipy,lo,hi;
  114.  
  115.         if (ninjakd2_foreground_videoram[offs*2] | ninjakd2_foreground_videoram[offs*2+1])
  116.         {
  117.             sx = (offs % 32) << 3;
  118.             sy = (offs >> 5) << 3;
  119.  
  120.             lo = ninjakd2_foreground_videoram[offs*2];
  121.             hi = ninjakd2_foreground_videoram[offs*2+1];
  122.             tile = ((hi & 0xc0) << 2) | lo;
  123.             flipx = hi & 0x20;
  124.             flipy = hi & 0x10;
  125.             palette = hi & 0x0f;
  126.  
  127.             drawgfx(bitmap,Machine->gfx[2],
  128.                         tile,
  129.                         palette,
  130.                         flipx,flipy,
  131.                         sx,sy,
  132.                         &Machine->drv->visible_area,TRANSPARENCY_PEN, 15);
  133.         }
  134.  
  135.     }
  136. }
  137.  
  138.  
  139. void ninjakd2_draw_background(struct osd_bitmap *bitmap)
  140. {
  141.     int offs;
  142.  
  143.     /* for every character in the Video RAM, check if it has been modified */
  144.     /* since last time and update it accordingly. */
  145.  
  146.     for (offs = 0 ;offs < ninjakd2_backgroundram_size / 2; offs++)
  147.     {
  148.         int sx,sy,tile,palette,flipx,flipy,lo,hi;
  149.  
  150.         if (bg_dirtybuffer[offs])
  151.         {
  152.             sx = (offs % 32) << 4;
  153.             sy = (offs >> 5) << 4;
  154.  
  155.             bg_dirtybuffer[offs] = 0;
  156.  
  157.             lo = ninjakd2_background_videoram[offs*2];
  158.             hi = ninjakd2_background_videoram[offs*2+1];
  159.             tile = ((hi & 0xc0) << 2) | lo;
  160.             flipx = hi & 0x20;
  161.             flipy = hi & 0x10;
  162.             palette = hi & 0x0f;
  163.             drawgfx(bitmap,Machine->gfx[0],
  164.                       tile,
  165.                       palette,
  166.                       flipx,flipy,
  167.                       sx,sy,
  168.                       0,TRANSPARENCY_NONE,0);
  169.         }
  170.  
  171.     }
  172. }
  173.  
  174. void ninjakd2_draw_sprites(struct osd_bitmap *bitmap)
  175. {
  176.     int offs;
  177.  
  178.     /* Draw the sprites */
  179.  
  180.     for (offs = 11 ;offs < ninjakd2_spriteram_size; offs+=16)
  181.     {
  182.         int sx,sy,tile,palette,flipx,flipy;
  183.  
  184.         if (ninjakd2_spriteram[offs+2] & 2)
  185.         {
  186.             sx = ninjakd2_spriteram[offs+1];
  187.             sy = ninjakd2_spriteram[offs];
  188.             if (ninjakd2_spriteram[offs+2] & 1) sx-=256;
  189.             tile = ninjakd2_spriteram[offs+3]+((ninjakd2_spriteram[offs+2] & 0xc0)<<2);
  190.             flipx = ninjakd2_spriteram[offs+2] & 0x10;
  191.             flipy = ninjakd2_spriteram[offs+2] & 0x20;
  192.             palette = ninjakd2_spriteram[offs+4] & 0x0f;
  193.             drawgfx(bitmap,Machine->gfx[1],
  194.                         tile,
  195.                         palette,
  196.                         flipx,flipy,
  197.                         sx,sy,
  198.                         &Machine->drv->visible_area,
  199.                         TRANSPARENCY_PEN, 15);
  200.         }
  201.     }
  202. }
  203.  
  204.  
  205. /***************************************************************************
  206.  
  207.   Draw the game screen in the given osd_bitmap.
  208.   Do NOT call osd_update_display() from this function, it will be called by
  209.   the main emulation engine.
  210.  
  211. ***************************************************************************/
  212. void ninjakd2_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  213. {
  214.     int scrollx,scrolly;
  215.  
  216.     if (palette_recalc ())
  217.         memset(bg_dirtybuffer, 1, ninjakd2_backgroundram_size / 2);
  218.  
  219.     if (bg_enable)
  220.         ninjakd2_draw_background(bitmap_bg);
  221.  
  222.     scrollx = -((ninjakd2_scrollx_ram[0]+ninjakd2_scrollx_ram[1]*256) & 0x1FF);
  223.     scrolly = -((ninjakd2_scrolly_ram[0]+ninjakd2_scrolly_ram[1]*256) & 0x1FF);
  224.  
  225.     if (sp_overdraw)    /* overdraw sprite mode */
  226.     {
  227.         ninjakd2_draw_sprites(bitmap_sp);
  228.         ninjakd2_draw_foreground(bitmap_sp);
  229.         copyscrollbitmap(bitmap,bitmap_bg,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  230.         copybitmap(bitmap,bitmap_sp,0,0,0,0,&Machine->drv->visible_area,TRANSPARENCY_PEN, 15);
  231.     }
  232.     else             /* normal sprite mode */
  233.     {
  234.         copyscrollbitmap(bitmap,bitmap_bg,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  235.         ninjakd2_draw_sprites(bitmap);
  236.         ninjakd2_draw_foreground(bitmap);
  237.     }
  238.  
  239. }
  240.